home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / m-atari.h < prev    next >
Text File  |  1992-03-25  |  17KB  |  479 lines
  1.  
  2. /* this def file consed up by jrd for atari st.  many defs stolen
  3.    from 'm-sun2.h' */
  4.  
  5. /* don't know where this is supposed to come from. */
  6. #define MAXPATHLEN 80
  7.  
  8. /* Parameters for execution on a Sun, for GDB, the GNU debugger.
  9.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  10.  
  11. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  12. WARRANTY.  No author or distributor accepts responsibility to anyone
  13. for the consequences of using it or for whether it serves any
  14. particular purpose or works at all, unless he says so in writing.
  15. Refer to the GDB General Public License for full details.
  16.  
  17. Everyone is granted permission to copy, modify and redistribute GDB,
  18. but only under the conditions described in the GDB General Public
  19. License.  A copy of this license is supposed to have been given to you
  20. along with GDB so you can know your rights and responsibilities.  It
  21. should be in a file named COPYING.  Among other things, the copyright
  22. notice and this notice must be preserved on all copies.
  23.  
  24. In other words, go ahead and share GDB, but don't try to stop
  25. anyone else from sharing it farther.  Help stamp out software hoarding!
  26. */
  27.  
  28. /* Define the bit, byte, and word ordering of the machine.  */
  29. #define BITS_BIG_ENDIAN
  30. #define BYTES_BIG_ENDIAN
  31. #define WORDS_BIG_ENDIAN
  32.  
  33. /* Define this if the C compiler puts an underscore at the front
  34.    of external names before giving them to the linker.  */
  35.  
  36. #define NAMES_HAVE_UNDERSCORE
  37.  
  38. /* Debugger information will be in DBX format.  */
  39.  
  40. #define READ_DBX_FORMAT
  41.  
  42. /* Offset from address of function to start of its code.
  43.    Zero on most machines.  */
  44.  
  45. #define FUNCTION_START_OFFSET 0
  46.  
  47. /* Advance PC across any function entry prologue instructions
  48.    to reach some "real" code.  */
  49.  
  50. #define SKIP_PROLOGUE(pc)   \
  51. { register int op = read_memory_integer (pc, 2);    \
  52.   if (op == 0047126)                    \
  53.     pc += 4;   /* Skip link #word */            \
  54.   else if (op == 0044016)                \
  55.     pc += 6;   /* Skip link #long */            \
  56.   /* Not sure why branches are here.  */                \
  57.   /* From m-isi.h, m-altos.h */                         \
  58.   else if (op == 0060000)                \
  59.     pc += 4;   /* Skip bra #word */            \
  60.   else if (op == 00600377)                \
  61.     pc += 6;   /* skip bra #long */            \
  62.   else if ((op & 0177400) == 0060000)            \
  63.     pc += 2;   /* skip bra #char */            \
  64. }
  65.  
  66. /* Immediately after a function call, return the saved pc.
  67.    Can't go through the frames for this because on some machines
  68.    the new frame is not set up until the new function executes
  69.    some instructions.  */
  70.  
  71. #define SAVED_PC_AFTER_CALL(frame) \
  72. read_memory_integer (read_register (SP_REGNUM), 4)
  73.  
  74. /* This is the amount to subtract from u.u_ar0
  75.    to get the offset in the core file of the register values.  */
  76.  
  77. /* this can't possibly work on atari; one address space...
  78. #define KERNEL_U_ADDR 0x2800
  79. */
  80.  
  81. /* Address of end of stack space.  */
  82.  
  83. /* ditto...
  84. #define STACK_END_ADDR 0x1000000
  85. */
  86.  
  87. /* Stack grows downward.  */
  88.  
  89. #define INNER_THAN <
  90.  
  91. /* Sequence of bytes for breakpoint instruction.  */
  92.  
  93. #define BREAKPOINT {0x4e, 0x4f}
  94.  
  95. /* Amount PC must be decremented by after a breakpoint.
  96.    This is often the number of bytes in BREAKPOINT
  97.    but not always.  */
  98.  
  99. #define DECR_PC_AFTER_BREAK 2
  100.  
  101. /* Nonzero if instruction at PC is a return instruction.  */
  102.  
  103. #define ABOUT_TO_RETURN(pc) ((read_memory_integer (pc, 2) & ~0x3) == 0x4e74)
  104.  
  105. /* Return 1 if P points to an invalid floating point value.  */
  106.  
  107. #define INVALID_FLOAT(p, len) 0   /* Just a first guess; not checked */
  108.  
  109. /* Say how long registers are.  */
  110.  
  111. #define REGISTER_TYPE long
  112.  
  113. /* Number of machine registers */
  114.  
  115. #define NUM_REGS 18
  116.  
  117. /* Number that are really general registers */
  118.  
  119. #define NUM_GENERAL_REGS 16
  120.  
  121. /* Initializer for an array of names of registers.
  122.    There should be NUM_REGS strings in this initializer.  */
  123.  
  124. #define REGISTER_NAMES {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", "pc", "ps"}
  125.  
  126. /* Register numbers of various important registers.
  127.    Note that some of these values are "real" register numbers,
  128.    and correspond to the general registers of the machine,
  129.    and some are "phony" register numbers which are too large
  130.    to be actual register numbers as far as the user is concerned
  131.    but do serve to get the desired values when passed to read_register.  */
  132.  
  133. /* note that we do these differently than the sun one; our order is
  134.    FP, SP, PC, PS */
  135. #define A1_REGNUM 9
  136. #define FP_REGNUM 14        /* Contains address of executing stack frame */
  137. #define SP_REGNUM 15        /* Contains address of top of stack */
  138. #define PC_REGNUM 16        /* Contains program counter */
  139. #define PS_REGNUM 17        /* Contains processor status */
  140.  
  141. /* Total amount of space needed to store our copies of the machine's
  142.    register state, the array `registers'.  */
  143. #define REGISTER_BYTES (16*4+8)
  144.  
  145. /* Index within `registers' of the first byte of the space for
  146.    register N.  */
  147.  
  148. #define REGISTER_BYTE(N)  ((N) * 4)
  149.  
  150. /* Number of bytes of storage in the actual machine representation
  151.    for register N.  On the 68000, all regs are 4 bytes.  */
  152.  
  153. #define REGISTER_RAW_SIZE(N) 4
  154.  
  155. /* Number of bytes of storage in the program's representation
  156.    for register N.  On the 68000, all regs are 4 bytes.  */
  157.  
  158. #define REGISTER_VIRTUAL_SIZE(N) 4
  159.  
  160. /* Largest value REGISTER_RAW_SIZE can have.  */
  161.  
  162. #define MAX_REGISTER_RAW_SIZE 4
  163.  
  164. /* Largest value REGISTER_VIRTUAL_SIZE can have.  */
  165.  
  166. #define MAX_REGISTER_VIRTUAL_SIZE 4
  167.  
  168. /* Nonzero if register N requires conversion
  169.    from raw format to virtual format.  */
  170.  
  171. #define REGISTER_CONVERTIBLE(N) 0
  172.  
  173. /* Convert data from raw format for register REGNUM
  174.    to virtual format for register REGNUM.  */
  175.  
  176. #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO)  bcopy ((FROM), (TO), 4);
  177.  
  178. /* Convert data from virtual format for register REGNUM
  179.    to raw format for register REGNUM.  */
  180.  
  181. #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO)  bcopy ((FROM), (TO), 4);
  182.  
  183. /* Return the GDB type object for the "standard" data type
  184.    of data in register N.  */
  185.  
  186. #define REGISTER_VIRTUAL_TYPE(N)  builtin_type_int
  187.  
  188. /* Store the address of the place in which to copy the structure the
  189.    subroutine will return.  This is called from call_function. */
  190.  
  191. #define STORE_STRUCT_RETURN(ADDR, SP) \
  192.   { write_register (A1_REGNUM, (ADDR)); }
  193.  
  194. /* Extract from an array REGBUF containing the (raw) register state
  195.    a function return value of type TYPE, and copy that, in virtual format,
  196.    into VALBUF.  */
  197.  
  198.  
  199. #if 0
  200. #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
  201.    bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
  202. #endif
  203. #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
  204.    bcopy ((char *)(REGBUF) +                                           \
  205.        (TYPE_LENGTH (TYPE) < 4  ?  4 - TYPE_LENGTH (TYPE)  :  0),  \
  206.       VALBUF, TYPE_LENGTH (TYPE))
  207.  
  208. /* Write into appropriate registers a function return value
  209.    of type TYPE, given in virtual format.  */
  210.  
  211. #define STORE_RETURN_VALUE(TYPE,VALBUF) \
  212.   write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
  213.  
  214. /* Extract from an array REGBUF containing the (raw) register state
  215.    the address in which a function should return its structure value,
  216.    as a CORE_ADDR (or an expression that can be used as one).  */
  217.  
  218. #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
  219.  
  220. /* This is a piece of magic that is given a register number REGNO
  221.    and as BLOCKEND the address in the system of the end of the user structure
  222.    and stores in ADDR the address in the kernel or core dump
  223.    of that register.  */
  224.  
  225. #define REGISTER_U_ADDR(addr, blockend, regno)        \
  226. { addr = blockend + regno * 4; }
  227.  
  228.  
  229. /* Describe the pointer in each stack frame to the previous stack frame
  230.    (its caller).  */
  231.  
  232. /* FRAME_CHAIN takes a frame's nominal address
  233.    and produces the frame's chain-pointer.
  234.  
  235.    FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
  236.    and produces the nominal address of the caller frame.
  237.  
  238.    However, if FRAME_CHAIN_VALID returns zero,
  239.    it means the given frame is the outermost one and has no caller.
  240.    In that case, FRAME_CHAIN_COMBINE is not used.  */
  241.  
  242. /* In the case of the Sun, the frame's nominal address
  243.    is the address of a 4-byte word containing the calling frame's address.  */
  244.  
  245. #if 1
  246. #define FRAME_CH